home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / calc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-22  |  15.3 KB  |  758 lines
  1. #include "FileXStructs.h"
  2. #include "FileXStrings.h"
  3. #include "allprotos.h"
  4. #include "WindowInfo.h"
  5.  
  6. enum { CM_BIN = 0, CM_DEC, CM_HEX, CM_OCT, CM_RAW, CM_TEXT };
  7. enum { CO_GLEICH = 0, CO_ADD, CO_SUB, CO_DIV, CO_MUL };
  8.  
  9. static BOOL IsCharInMode( char Zeichen, UWORD Mode )
  10. {
  11.     switch( Mode )
  12.     {
  13.         case CM_BIN:
  14.             return(( BOOL )(( Zeichen == '0' ) || ( Zeichen == '1' )));
  15.             break;
  16.  
  17.         case CM_DEC:
  18.             return(( BOOL )isdigit( Zeichen ));
  19.             break;
  20.  
  21.         case CM_HEX:
  22.             return(( BOOL )isxdigit( Zeichen ));
  23.             break;
  24.  
  25.         case CM_OCT:
  26.             return(( BOOL )(( Zeichen >= '0' ) && ( Zeichen <= '7' )));
  27.             break;
  28.     }
  29. }
  30.  
  31. static UBYTE *CalcTasten[] =
  32. {
  33.     "D", "E", "F", ">",
  34.     "A", "B", "C", "<",
  35.     "7", "8", "9", "/",
  36.     "4", "5", "6", "*",
  37.     "1", "2", "3", "-",
  38.     "0", "±", "=", "+"
  39. };
  40.  
  41. static UBYTE *CalcModes[] =
  42. {
  43.     MSG_GADGET_CALC_CYCLE_BIN,
  44.     MSG_GADGET_CALC_CYCLE_DEC,
  45.     MSG_GADGET_CALC_CYCLE_HEX,
  46.     MSG_GADGET_CALC_CYCLE_OCT,
  47.     0
  48. };
  49.  
  50. static Localized = FALSE;
  51.  
  52. static struct WindowInfo *CalcWI;
  53. static struct Window *CalcWnd;
  54. static struct Gadget *CalcGList;
  55. static struct Gadget *CalcGadgets[27];
  56. static long CalcLeft = -1, CalcTop = -1, CalcWidth = -1;
  57.  
  58. static UWORD CalcMode = CM_DEC, CalcOp = CO_GLEICH;
  59. static long CalcDisplayWert, LastCalcWert;
  60. static BOOL NewCalcWert = FALSE;
  61.  
  62. static long DoCalcOp( UWORD Op, long eins, long zwei )
  63. {
  64.     switch( Op )
  65.     {
  66.         case CO_ADD:
  67.             return( eins + zwei );
  68.             break;
  69.         case CO_SUB:
  70.             return( eins - zwei );
  71.             break;
  72.         case CO_MUL:
  73.             return( eins * zwei );
  74.             break;
  75.         case CO_DIV:
  76.             if( zwei )
  77.                 return( eins / zwei );
  78.             else
  79.             {
  80.                 DisplayLocaleText( MSG_INFO_CALC_DIVISONBYZERO );
  81.                 return( 0 );
  82.             }
  83.             break;
  84.     }
  85. }
  86.  
  87. static ULONG __saveds __asm CalcHookFunc(    register __a0 struct Hook *hook,
  88.                                                         register __a2 struct SGWork *sgw,
  89.                                                         register __a1 unsigned long *msg    )
  90. {
  91. /*    struct InputEvent *ie;*/
  92.     ULONG return_code = ~0;
  93.  
  94.     if( *msg == SGH_KEY )
  95.     {
  96. /*        ie = sgw->IEvent;
  97.  
  98.  
  99. {
  100.     void kprintf(UBYTE *fmt,...);
  101.  
  102.     kprintf("*msg = %ld\n", *msg );
  103.     kprintf("Work:%s:\n", sgw->WorkBuffer );
  104.     kprintf("Prev:%s:\n", sgw->PrevBuffer );
  105.     kprintf("Modes:%lx:\n", sgw->Modes );
  106.     kprintf("code:%lx:\n", sgw->Code);
  107.     kprintf("Prev:%s:\n", sgw->PrevBuffer );
  108.     kprintf("BufferPos:%lx:\n", sgw->BufferPos );
  109.     kprintf("NumChars:%lx:\n", sgw->NumChars );
  110.     kprintf("Actions:%lx:\n", sgw->Actions );
  111.     kprintf("EditOp:%lx:\n", sgw->EditOp);
  112.  
  113.     kprintf("IE Class:%lx:\n", ie->ie_Class);
  114.     kprintf("IE Qualifier:%lx:\n", ie->ie_Qualifier);
  115.     kprintf("IE Code:%lx:\n", ie->ie_Code);
  116.     kprintf("**************************\n");
  117. }
  118. */
  119.  
  120.         switch( sgw->EditOp )
  121.         {
  122.             case EO_INSERTCHAR:
  123. /*                if( ie->ie_Class == IECLASS_RAWKEY )*/
  124.                 {
  125.                     if(( !IsCharInMode( sgw->Code, CalcMode ))    ||
  126.                         ( sgw->WorkBuffer[0] == '0' ))
  127.                         sgw->Actions = SGA_BEEP;
  128.                 }
  129.                 break;
  130.  
  131.             case EO_NOOP:
  132.                 break;
  133.  
  134.             case EO_ENTER:
  135.                 break;
  136.  
  137.             case EO_BIGCHANGE:
  138.                 {
  139.                     int k;
  140.  
  141.                     for( k = 0; k < strlen( sgw->WorkBuffer  ); k++ )
  142.                     {
  143.                         if( !IsCharInMode( sgw->WorkBuffer[ k ], CalcMode ))
  144.                         {
  145.                             sgw->Actions = SGA_BEEP;
  146.                         }
  147.                     }
  148.                 }
  149.                 break;
  150.  
  151.             default:
  152. /*                MyBeep();*/
  153.                 break;
  154.         }
  155.     }
  156.     else
  157.         return_code = 0;
  158.  
  159.    return(return_code);
  160. }
  161.  
  162. static struct Hook CalcHook =
  163. {
  164.     0, 0, (ULONG (*)()) CalcHookFunc, 0, 0
  165. };
  166.  
  167. #define MAXCALCSTRINGLEN (8 * 4 + 2)
  168.  
  169. static void SetCalcDisplayWert( ULONG Number )
  170. {
  171.     UBYTE String[ MAXCALCSTRINGLEN ];
  172.  
  173.     CalcDisplayWert = Number;
  174.  
  175.     switch( CalcMode )
  176.     {
  177.         case CM_DEC:
  178.             stcl_d( String, CalcDisplayWert );
  179.             break;
  180.  
  181.         case CM_HEX:
  182.             stcl_h( String, CalcDisplayWert );
  183.             break;
  184.  
  185.         case CM_OCT:
  186.             stcl_o( String, CalcDisplayWert );
  187.             break;
  188.  
  189.         case CM_BIN:
  190.             My_stcl_b( String, CalcDisplayWert );
  191.             break;
  192.     }
  193.  
  194.     GT_SetGadgetAttrs( CalcGadgets[ 24 ] , CalcWnd, NULL,
  195.                                 GTST_String, String,
  196.                                 TAG_DONE);
  197. }
  198.  
  199. static long GetCalcDisplayWert( void )
  200. {
  201.     UBYTE String[ MAXCALCSTRINGLEN ], *ptr;
  202.  
  203.     strcpy( ptr = String, GetString( CalcGadgets[ 24 ]));
  204.  
  205.     switch( CalcMode )
  206.     {
  207.         case CM_DEC:
  208.             stcd_l( String, &CalcDisplayWert );
  209.             break;
  210.  
  211.         case CM_HEX:
  212.             stch_l( String, &CalcDisplayWert );
  213.             break;
  214.  
  215.         case CM_OCT:
  216.             stco_l( String, &CalcDisplayWert );
  217.             break;
  218.  
  219.         case CM_BIN:
  220.             My_stcb_l( String, &CalcDisplayWert );
  221.             break;
  222.     }
  223.  
  224.     SetCalcDisplayWert( CalcDisplayWert );
  225.  
  226.     return( CalcDisplayWert );
  227. }
  228.  
  229. static void SubCalcChar( void )
  230. {
  231.     UBYTE String[ MAXCALCSTRINGLEN ];
  232.  
  233.     strcpy( String, GetString( CalcGadgets[ 24 ]));
  234.  
  235.     if( strlen( String ) == 1 )
  236.         String[ 0 ] = '0';
  237.     else
  238.         String[ strlen( String ) - 1 ] = 0;
  239.  
  240.     GT_SetGadgetAttrs( CalcGadgets[ 24 ] , CalcWnd, NULL,
  241.                                 GTST_String, String,
  242.                                 TAG_DONE);
  243. }
  244.  
  245. BOOL CalcOverflow( char *String, UWORD Mode )
  246. {
  247.     BOOL TooBig = FALSE;
  248.  
  249.     if( *String == '0' )
  250.         String++;
  251.  
  252.     switch( Mode )
  253.     {
  254.         case CM_DEC:
  255.             if( *String != '-' )
  256.             {
  257.                 if( strlen( String ) >= 10 )
  258.                 {
  259.                     if( strlen( String ) == 10 )
  260.                     {
  261.                         if( strcmp( String, "2147483648" ) >= 0 )
  262.                             TooBig = TRUE;
  263.                     }
  264.                     else
  265.                         TooBig = TRUE;
  266.                 }
  267.             }
  268.             else
  269.             {
  270.                 if( strlen( String+1 ) >= 10 )
  271.                 {
  272.                     if( strlen( String+1 ) == 10 )
  273.                     {
  274.                         if( strcmp( String+1, "2147483648" ) > 0 )
  275.                             TooBig = TRUE;
  276.                     }
  277.                     else
  278.                         TooBig = TRUE;
  279.                 }
  280.             }
  281.             break;
  282.  
  283.         case CM_HEX:
  284.             if( strlen( String ) > 8 )
  285.                 TooBig = TRUE;
  286.             break;
  287.  
  288.         case CM_OCT:
  289.             if( strlen( String ) >= 11 )
  290.             {
  291.                 if( strlen( String ) == 11 )
  292.                 {
  293.                     if( strcmp( String, "40000000000" ) >= 0 )
  294.                         TooBig = TRUE;
  295.                 }
  296.                 else
  297.                     TooBig = TRUE;
  298.             }
  299.             break;
  300.  
  301.         case CM_BIN:
  302.             if( strlen( String ) > 32 )
  303.                 TooBig = TRUE;
  304.             break;
  305.     }
  306.  
  307.     return( TooBig );
  308. }
  309.  
  310. static BOOL AddCalcChar( UBYTE Zeichen, UWORD Mode )
  311. {
  312.     UBYTE String[ MAXCALCSTRINGLEN ];
  313.     BOOL TooBig;
  314.  
  315.     if( !IsCharInMode( Zeichen, Mode )) return( FALSE );
  316.  
  317.     if( NewCalcWert == TRUE )
  318.     {
  319.         NewCalcWert = FALSE;
  320.         *String = 0;
  321.     }
  322.     else
  323.     {
  324.         strcpy( String, GetString( CalcGadgets[ 24 ]));
  325.  
  326.         if( *String == '0' )
  327.         {
  328.             strcpy( String, String + 1 );
  329.         }
  330.     }
  331.  
  332.     strncat( String, &Zeichen, 1 );
  333.  
  334.     TooBig = CalcOverflow( String, Mode );
  335.  
  336.     if( !TooBig )
  337.         GT_SetGadgetAttrs( CalcGadgets[ 24 ] , CalcWnd, NULL,
  338.                                     GTST_String, String,
  339.                                     TAG_DONE);
  340.     else
  341.         DisplayLocaleText( MSG_INFO_CALC_OVERFLOW );
  342.  
  343.     return( TRUE );
  344. }
  345.  
  346. static void SetCalcMode( UWORD Mode )
  347. {
  348.     long wert;
  349.  
  350.     wert = GetCalcDisplayWert();
  351.  
  352.     CalcMode = Mode;
  353.  
  354.     SetCalcDisplayWert( wert );
  355.     
  356.     GT_SetGadgetAttrs( CalcGadgets[ 25 ] , CalcWnd, NULL,
  357.                                 GTCY_Active, Mode,
  358.                                 TAG_DONE);
  359. }
  360.  
  361. static void SetCalcOp( UWORD Op )
  362. {
  363.     if( NewCalcWert != TRUE )
  364.     {
  365.         if( CalcOp != CO_GLEICH )
  366.             SetCalcDisplayWert( DoCalcOp( CalcOp, LastCalcWert, GetCalcDisplayWert()));
  367.  
  368.         LastCalcWert = GetCalcDisplayWert();
  369.  
  370.         NewCalcWert = TRUE;
  371.     }
  372.  
  373.     CalcOp = Op;
  374. }
  375.  
  376. static MakeCalcGadgets( UWORD Breite )
  377. {
  378.     struct NewGadget ng;
  379.     struct Gadget *g;
  380.     int k;
  381.     UWORD ButtonBreite;
  382.  
  383.     if( CalcGList )
  384.     {
  385.         GetCalcDisplayWert();
  386.  
  387.         RemoveGList( CalcWnd, CalcGList, -1 );
  388.  
  389.         FreeGadgets( CalcGList );
  390.         CalcGList = NULL;
  391.     }
  392.  
  393.     if(! (g = CreateContext(&CalcGList)))
  394.         return(1L);
  395.  
  396.     ButtonBreite =  (Breite - ( 3 * INNERGADGETX + 2 * BORDERX + 2 * BEVELX + 2 * INNERX )) / 4;
  397.  
  398.     ng.ng_VisualInfo = VisualInfo;
  399.     ng.ng_TextAttr = &CalcWI->TA;
  400.     ng.ng_Flags = PLACETEXT_LEFT;
  401.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BEVELY + INNERY + BORDERY;
  402.     ng.ng_GadgetID = 0;
  403.  
  404.     ng.ng_Width = ButtonBreite;
  405.     ng.ng_Height = CalcWI->TF->tf_YSize + 6;
  406.     ng.ng_Flags = PLACETEXT_IN;
  407.  
  408.     for( k = 0; k < 24; k++ )
  409.     {
  410.         ng.ng_TopEdge =  Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BORDERY + BEVELY + BUTTONY + ( k / 4 ) * ( CalcWI->TF->tf_YSize + 6 + INNERGADGETY) + 2 * ( CalcWI->TF->tf_YSize + 6 + INNERGADGETY );
  411.         ng.ng_LeftEdge = Scr->WBorLeft + BORDERX + BEVELX + BUTTONX + ( k % 4 ) * ButtonBreite + ( k % 4 ) * INNERGADGETX;
  412.         ng.ng_GadgetText = CalcTasten[k];
  413.  
  414.         CalcGadgets[k] = g = CreateGadgetA( BUTTON_KIND, g, &ng, NULL );
  415.  
  416.         if(!g) return(2L);
  417.  
  418.         ng.ng_GadgetID++;
  419.     }
  420.  
  421.     {
  422.     static struct TagItem StringTags[6] =
  423.     {GTST_String, 0, GTST_MaxChars, 0,STRINGA_Justification, STRINGRIGHT, GTST_EditHook, (LONG) &CalcHook, TAG_DONE};
  424.     ng.ng_GadgetText = 0;
  425.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BORDERY + BEVELY + BUTTONY;
  426.     ng.ng_LeftEdge = Scr->WBorLeft + BORDERX + BEVELX + BUTTONX;
  427.     ng.ng_Width = Breite - 2 * BORDERX - 2 * BEVELX - 2 * INNERX;
  428.     ng.ng_Height = CalcWI->TF->tf_YSize + 6;
  429.     StringTags[0].ti_Data = 0;
  430.     StringTags[1].ti_Data = 32;    /* Max */
  431.  
  432.     CalcGadgets[k++] = g = CreateGadgetA( STRING_KIND, g, &ng, StringTags );
  433.     ng.ng_GadgetID++;
  434.     }
  435.  
  436.     {
  437.     static struct TagItem CycleTags[3] =
  438.     {GTCY_Labels, 0, GTCY_Active, 0, TAG_DONE};
  439.  
  440.     ng.ng_TopEdge = Scr->RastPort.TxHeight + Scr->WBorTop + 1 + BORDERY + BEVELY + BUTTONY + CalcWI->TF->tf_YSize + 6 + INNERGADGETY;
  441.     ng.ng_LeftEdge = Scr->WBorLeft + BORDERX + BEVELX + BUTTONX;
  442.     ng.ng_Width = Breite - 2 * BORDERX - 2 * BEVELX - 2 * INNERX;
  443.     ng.ng_Height = CalcWI->TF->tf_YSize + 6;
  444.  
  445.     CycleTags[0].ti_Data = ( ULONG )CalcModes;    /* Anzahl */
  446.     CycleTags[1].ti_Data = CalcMode;    /* Active */
  447.  
  448.     CalcGadgets[k] = g = CreateGadgetA( CYCLE_KIND, g, &ng, CycleTags);
  449.     }
  450.  
  451.     if( CalcWnd )
  452.     {
  453.         SetzeMuster( CalcWnd );
  454.  
  455.         MyFilledDrawBevelBox(CalcWnd->RPort,    CalcWnd->BorderLeft + BORDERX,
  456.                                                             CalcWnd->BorderTop + BORDERY,
  457.                                                             CalcWnd->Width - CalcWnd->BorderRight - CalcWnd->BorderLeft - BORDERX * 2,
  458.                                                             CalcWnd->Height - CalcWnd->BorderBottom - CalcWnd->BorderTop - 2 * BORDERY,
  459.                                                             TRUE);
  460.     
  461.         AddGList( CalcWnd, CalcGList, -1, -1, 0);
  462.  
  463.         RefreshGadgets(CalcGList, CalcWnd, 0);
  464.         GT_RefreshWindow( CalcWnd, NULL );
  465.  
  466.         SetCalcDisplayWert( CalcDisplayWert );
  467.     }
  468. }
  469.  
  470. static void CalcToClip( void )
  471. {
  472.     long wert =    GetCalcDisplayWert();
  473.     SaveClip( ( STRPTR )&wert, 4 );
  474. }
  475.  
  476. static void ClipToCalc( void )
  477. {
  478.     ULONG Laenge;
  479.     UBYTE *String;
  480.  
  481.     String = GetClip( &Laenge );
  482.  
  483.     if(( Laenge > 4 ) || ( !Laenge ))
  484.     {
  485.         DisplayLocaleText( MSG_INFO_CALC_CLIPCONTENTSNOTANUMBER );
  486.     }
  487.     else
  488.     {
  489.         long wert;
  490.  
  491.         wert = String[0];
  492.         if( Laenge >= 2 ) wert = ( wert << 8 ) + String[1];
  493.         if( Laenge >= 3 ) wert = ( wert << 8 ) + String[2];
  494.         if( Laenge >= 4 ) wert = ( wert << 8 ) + String[3];
  495.  
  496.         SetCalcDisplayWert( wert );
  497.     }
  498.  
  499.     FreeMem( String, Laenge );
  500. }                            
  501.  
  502. static void DoCalcWndMsg( void )
  503. {
  504.     BOOL CloseMe = FALSE;
  505.     struct IntuiMessage    *m, Msg;
  506.     struct Gadget *gad;
  507.  
  508.     while( m = GT_GetIMsg( CalcWnd->UserPort ))
  509.     {
  510.         CopyMem((char *)m, (char *)&Msg, (long)sizeof(struct IntuiMessage));
  511.  
  512.         GT_ReplyIMsg(m);
  513.  
  514.         gad = (struct Gadget *) Msg.IAddress;
  515.  
  516.         switch( Msg.Class )
  517.         {
  518.             case    IDCMP_NEWSIZE:
  519.                 MakeCalcGadgets( CalcWnd->Width - CalcWnd->BorderLeft - CalcWnd->BorderRight );
  520.                 RefreshWindowFrame( CalcWnd );
  521.                 break;
  522.  
  523.             case    IDCMP_REFRESHWINDOW:
  524.                 GT_BeginRefresh( CalcWnd );
  525.                 GT_EndRefresh( CalcWnd, TRUE );
  526.                 break;
  527.  
  528.             case    IDCMP_RAWKEY:
  529.                 switch( Msg.Code )
  530.                 {
  531.                     case CURSORUP:
  532.                     case CURSORLEFT:
  533.                         SetCalcMode(( CalcMode + 1 ) % 4);
  534.                         break;
  535.  
  536.                     case CURSORDOWN:
  537.                     case CURSORRIGHT:
  538.                         SetCalcMode(( CalcMode + 3 ) % 4);
  539.                         break;
  540.                 }
  541.                 break;
  542.  
  543.             case    IDCMP_VANILLAKEY:
  544.                 if((( Msg.Code >= '0' ) && ( Msg.Code <= '9' )) ||
  545.                     (( ToUpper( Msg.Code ) >= 'A' ) && ( ToUpper( Msg.Code ) <= 'F' )))
  546.                 {
  547.                     AddCalcChar( Msg.Code, CalcMode );
  548.                     GetCalcDisplayWert();
  549.                 }
  550.                 else
  551.                 {
  552.                     switch( Msg.Code )
  553.                     {
  554.                         case 8:
  555.                             SubCalcChar();
  556.                             break;
  557.                         case 127:
  558.                             SetCalcDisplayWert( 0 );
  559.                             break;
  560.                         case 27:
  561.                             CloseMe = TRUE;
  562.                             break;
  563.                         case '\t':
  564.                             ActivateGadget( CalcGadgets[ 24 ], CalcWnd, 0 );
  565.                             break;
  566.                         case '<':
  567.                             CalcToClip();
  568.                             break;
  569.                         case '>':
  570.                             ClipToCalc();
  571.                             break;
  572.                         case ' ':
  573.                             ActivateWindow( AktuDI->Wnd );
  574.                             break;
  575.                         case '.':
  576.                             SetCalcDisplayWert( - GetCalcDisplayWert());
  577.                             if( NewCalcWert == TRUE )
  578.                                 LastCalcWert = GetCalcDisplayWert();
  579.                             break;
  580.                         case '+':
  581.                             SetCalcOp( CO_ADD );
  582.                             break;
  583.                         case '-':
  584.                             SetCalcOp( CO_SUB );
  585.                             break;
  586.                         case '/':
  587.                             SetCalcOp( CO_DIV );
  588.                             break;
  589.                         case '*':
  590.                             SetCalcOp( CO_MUL );
  591.                             break;
  592.                         case 13:
  593.                         case '=':
  594.                             SetCalcOp( CO_GLEICH );
  595.                             break;
  596.                     }
  597.  
  598.                 }
  599.                 break;
  600.  
  601.             case    IDCMP_CLOSEWINDOW:
  602.                 CloseMe = TRUE;
  603.                 break;
  604.  
  605.             case    IDCMP_GADGETUP:
  606.                 switch( gad->GadgetID )
  607.                 {    
  608.                     case 25:
  609.                         SetCalcMode( Msg.Code );
  610.                         break;
  611.                     case 21:        /* ± */
  612.                         SetCalcDisplayWert( - GetCalcDisplayWert());
  613.                         if( NewCalcWert == TRUE )
  614.                             LastCalcWert = GetCalcDisplayWert();
  615.                         break;
  616.                     case 23:        /* + */
  617.                         SetCalcOp( CO_ADD );
  618.                         break;
  619.                     case 19:        /* - */
  620.                         SetCalcOp( CO_SUB );
  621.                         break;
  622.                     case 11:        /* / */
  623.                         SetCalcOp( CO_DIV );
  624.                         break;
  625.                     case 15:        /* * */
  626.                         SetCalcOp( CO_MUL );
  627.                         break;
  628.                     case 22:        /* = */
  629.                         SetCalcOp( CO_GLEICH );
  630.                         break;
  631.                     case 7:        /* < */
  632.                         CalcToClip();
  633.                         break;
  634.                     case 3:        /* > */
  635.                         ClipToCalc();
  636.                         break;
  637.                     case 24:
  638.                         if( CalcOverflow( GetString( CalcGadgets[ 24 ]), CalcMode ))
  639.                         {
  640.                             DisplayLocaleText( MSG_INFO_CALC_OVERFLOW );
  641.                             ActivateGadget( CalcGadgets[ 24 ], CalcWnd, 0 );
  642.                         }
  643.                         break;
  644.                     default:
  645.                         AddCalcChar( *CalcTasten[ gad->GadgetID ], CalcMode );
  646.                         GetCalcDisplayWert();
  647.                         break;
  648.                 }
  649.         }
  650.     }
  651.  
  652.     if( CloseMe )
  653.         CloseCalc();
  654. }
  655.  
  656. BOOL OpenCalc( void )
  657. {
  658.     if( CalcWnd )
  659.     {
  660.         ActivateWindow( CalcWnd );
  661.         return( TRUE );
  662.     }
  663.  
  664.         /* Lokalisieren des Cyclegadgets */
  665.  
  666.     if( !Localized )
  667.     {
  668.         char **s;
  669.  
  670.         Localized = TRUE;
  671.         s = CalcModes;
  672.  
  673.         while( *s )
  674.         {
  675.             *s = GetStr( *s );
  676.             s++;
  677.         }
  678.     }
  679.  
  680.     if( CalcTop == -1 ) CalcTop = AktuDI->Wnd->TopEdge;
  681.     if( CalcLeft == -1 ) CalcLeft = AktuDI->Wnd->LeftEdge + AktuDI->Wnd->Width;
  682.  
  683.     if( CalcWI = NewCalcSetup( Scr ))
  684.     {
  685.         short k;
  686.         ULONG MaxCalcWidth = 0, MinWidth;
  687.         UWORD CalcHeight;
  688.  
  689.         for( k = 0; k < 24; k++ )
  690.         {
  691.             WORD Width;
  692.  
  693.             if((Width = TextLength(&CalcWI->RP,CalcTasten[k],1)) > MaxCalcWidth)
  694.                 MaxCalcWidth = Width;
  695.         }
  696.  
  697.         MinWidth = MaxCalcWidth * 4 * 3 + 3 * INNERGADGETX + 2 * BORDERX + 2 * BEVELX + 2 * INNERX;
  698.  
  699.         if(( CalcWidth == -1) || ( MinWidth > CalcWidth )) CalcWidth = MinWidth;
  700.  
  701.         CalcHeight = (CalcWI->TF->tf_YSize + 6) * 8 + INNERGADGETY * 7 + 2 * BORDERY + 2 * BEVELY + 2 * INNERY;
  702.  
  703. #ifndef WFLG_SIZEBOTTOM
  704. #define WFLG_SIZEBOTTOM WFLG_SIZEBBOTTOM
  705. #endif
  706.  
  707.         if ( ! ( CalcWnd = OpenWindowTags( NULL,
  708.             WA_Left,    CalcLeft,
  709.             WA_Top,        CalcTop,
  710.             WA_InnerWidth,    CalcWidth,
  711.             WA_InnerHeight,    CalcHeight,
  712.             WA_MaxWidth,    -1,
  713.             WA_MinWidth,    MinWidth,
  714.             WA_IDCMP,    BUTTONIDCMP | INTEGERIDCMP | TEXTIDCMP | IDCMP_CLOSEWINDOW | IDCMP_RAWKEY | IDCMP_VANILLAKEY | IDCMP_REFRESHWINDOW | IDCMP_NEWSIZE,
  715.             WA_Flags,    WFLG_SIZEGADGET | WFLG_SIZEBOTTOM | WFLG_DRAGBAR | WFLG_DEPTHGADGET | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH | WFLG_ACTIVATE | WFLG_RMBTRAP,
  716.             WA_Title,    GetStr( MSG_WINDOWTITLE_CALCULATOR ),
  717.             WA_ScreenTitle,    "FileX '94",
  718.             WA_PubScreen,    Scr,
  719.             TAG_DONE )))
  720.             return(3L);
  721.  
  722.         MakeCalcGadgets( CalcWidth );
  723.  
  724.         mainflags |= MF_CALC;
  725.  
  726.         MyAddSignal( 1L << CalcWnd->UserPort->mp_SigBit, &DoCalcWndMsg );
  727.     }
  728. }
  729.  
  730. void CloseCalc( void )
  731. {
  732.     MyRemoveSignal( 1L << CalcWnd->UserPort->mp_SigBit );
  733.  
  734.     mainflags &= ~MF_CALC;
  735.  
  736.     if( CalcWnd )
  737.     {
  738.         CalcLeft = CalcWnd->LeftEdge;
  739.         CalcTop = CalcWnd->TopEdge;
  740.         CalcWidth = CalcWnd->Width - CalcWnd->BorderLeft - CalcWnd->BorderRight;
  741.  
  742.         CloseWindow( CalcWnd );
  743.         CalcWnd = NULL;
  744.     }
  745.  
  746.     if( CalcGList )
  747.     {
  748.         FreeGadgets( CalcGList );
  749.         CalcGList = NULL;
  750.     }
  751.  
  752.     if( CalcWI )
  753.     {
  754.         NewCalcCleanup( CalcWI );
  755.         CalcWI = NULL;
  756.     }
  757. }
  758.